home *** CD-ROM | disk | FTP | other *** search
/ Just Call Me Internet / Just Call Me Internet.iso / prog / atari / c / nos042_s / session.c < prev    next >
C/C++ Source or Header  |  1994-09-16  |  9KB  |  459 lines
  1. /* NOS User Session control
  2.  * Copyright 1991 Phil Karn, KA9Q
  3.  */
  4.  
  5. /****************************************************************************
  6. *    $Id: session.c 1.3 93/07/16 11:50:11 ROOT_DOS Exp $
  7. *    24 Oct 92    1.2        GT    rlogin                                            *
  8. *    08 May 93    1.3        GT    Fix warnings.                                    *
  9. *
  10. *  ATARI Version by David Nash - dnash@chaos.demon.co.uk
  11. *
  12. *  __stdargs upload, remove new/swap/free screen calls
  13. *
  14. ****************************************************************************/
  15.  
  16. #include <stdio.h>
  17. #include "global.h"
  18. #include "mbuf.h"
  19. #include "proc.h"
  20. #include "ftpcli.h"
  21. #include "icmp.h"
  22. #include "telnet.h"
  23. #include "tty.h"
  24. #include "session.h"
  25. #include "hardware.h"
  26. #include "socket.h"
  27. #include "cmdparse.h"
  28. #include "commands.h"
  29. #include "main.h"
  30.  
  31. struct session *Sessions;
  32. struct session *Command;
  33. struct session *Current;
  34. struct session *Lastcurr;
  35. int Row;
  36. int Morewait;
  37.  
  38. char Notval[] = "Not a valid control block\n";
  39. static char Badsess[] = "Invalid session\n";
  40. char *Sestypes[] = {
  41.     "",
  42.     "Telnet",
  43.     "FTP",
  44.     "AX25",
  45.     "Finger",
  46.     "Ping",
  47.     "NET/ROM",
  48.     "Command",
  49.     "More",
  50.     "Hopcheck",
  51.     "Tip",
  52.     "PPP PAP",
  53.     "Dial",
  54.     "Query",
  55.     "Cache",
  56.     "Rlogin"
  57. };
  58.  
  59. /* Convert a character string containing a decimal session index number
  60.  * into a pointer. If the arg is NULLCHAR, use the current default session.
  61.  * If the index is out of range or unused, return NULLSESSION.
  62.  */
  63. struct session *
  64. sessptr(cp)
  65. char *cp;
  66. {
  67.     register struct session *sp;
  68.     unsigned int i;
  69.  
  70.     if(cp == NULLCHAR){
  71.         sp = Lastcurr;
  72.     } else {
  73.         i = (unsigned)atoi(cp);
  74.         if(i >= Nsessions)
  75.             sp = NULLSESSION;
  76.         else
  77.             sp = &Sessions[i];
  78.     }
  79.     if(sp == NULLSESSION || sp->type == FREE)
  80.         sp = NULLSESSION;
  81.  
  82.     return sp;
  83. }
  84.  
  85. /* Select and display sessions */
  86. int
  87. dosession(argc,argv,p)
  88. int argc;
  89. char *argv[];
  90. void *p;
  91. {
  92.     struct session *sp;
  93.     struct sockaddr fsocket;
  94.     int i,k,s;
  95.     int r,t;
  96.     char *cp;
  97.  
  98.     sp = (struct session *)p;
  99.  
  100.     if(argc > 1){
  101.         if((sp = sessptr(argv[1])) != NULLSESSION){
  102.             go(0,NULL,sp);
  103.         } else
  104.             tprintf("Session %s not active\n",argv[1]);
  105.         return 0;
  106.     }
  107.     tprintf(" #  S#  Type     Rcv-Q Snd-Q State        Remote socket\n");
  108.     for(sp=Sessions; sp < &Sessions[Nsessions];sp++){
  109.         if(sp->type == FREE || sp->type == COMMAND)
  110.             continue;
  111.  
  112.         /* Rcv-Q includes output pending at the screen driver */
  113.         r = socklen(sp->output,1);
  114.         t = 0;
  115.         cp = NULLCHAR;
  116.         if((s = sp->s) != -1){
  117.             i = SOCKSIZE;
  118.             s = sp->s;
  119.             k = getpeername(s,(char *)&fsocket,&i);
  120.             r += socklen(s,0);
  121.             t += socklen(s,1);
  122.             cp = sockstate(s);
  123.         }
  124.         tprintf("%c", (Lastcurr == sp)? '*':' ');
  125.         tprintf("%-3u", (unsigned)(sp - Sessions));
  126.         tprintf("%-4d%-8s%6d%6d %-13s",
  127.          s,
  128.          Sestypes[sp->type],
  129.          r,
  130.          t,
  131.          (cp != NULLCHAR) ? cp : "");
  132.         if(sp->name != NULLCHAR)
  133.             tprintf("%s ",sp->name);
  134.         if(sp->s != -1 && k == 0)
  135.             tprintf("(%s)",psocket(&fsocket));
  136.  
  137.         tprintf("\n");
  138.         if(sp->type == FTP && (s = sp->cb.ftp->data) != -1){
  139.             /* Display data channel, if any */
  140.             i = SOCKSIZE;
  141.             k = getpeername(s,(char *)&fsocket,&i);
  142.             r = socklen(s,0);
  143.             t = socklen(s,1);
  144.             cp = sockstate(s);
  145.             tprintf("    %-4d%-8s%6d%6d %-13s%s",
  146.              s,
  147.              Sestypes[sp->type],
  148.              r,
  149.              t,
  150.              (cp != NULLCHAR) ? cp : "",
  151.              (sp->name != NULLCHAR) ? sp->name : "");
  152.             if(k == 0)
  153.                 tprintf(" (%s)",psocket(&fsocket));
  154.             if(tprintf("\n") == EOF)
  155.                 break;
  156.         }
  157.         if(sp->rfile != NULLCHAR)
  158.             tprintf("    Record: %s\n",sp->rfile);
  159.         if(sp->ufile != NULLCHAR)
  160.             tprintf("    Upload: %s\n",sp->ufile);
  161.     }
  162.     return 0;
  163. }
  164. /* Resume current session, and wait for it */
  165. int
  166. go(argc,argv,p)
  167. int argc;
  168. char *argv[];
  169. void *p;
  170. {
  171.     struct session *sp;
  172.  
  173.     sp = (struct session *)p;
  174.     if(sp == NULLSESSION || sp->type == FREE || sp->type == COMMAND)
  175.         return 0;
  176.     Current = sp;
  177. #ifndef ATARI    
  178.     swapscreen(Command,sp);
  179. #endif
  180.     psignal(sp,0);
  181.     return 0;
  182. }
  183. int
  184. doclose(argc,argv,p)
  185. int argc;
  186. char *argv[];
  187. void *p;
  188. {
  189.     struct session *sp;
  190.  
  191.     sp = (struct session *)p;
  192.     if(argc > 1)
  193.         sp = sessptr(argv[1]);
  194.  
  195.     if(sp == NULLSESSION){
  196.         tprintf(Badsess);
  197.         return -1;
  198.     }
  199.     shutdown(sp->s,1);
  200.     return 0;
  201. }
  202. int
  203. doreset(argc,argv,p)
  204. int argc;
  205. char *argv[];
  206. void *p;
  207. {
  208.     struct session *sp;
  209.  
  210.     sp = (struct session *)p;
  211.     if(argc > 1)
  212.         sp = sessptr(argv[1]);
  213.  
  214.     if(sp == NULLSESSION){
  215.         tprintf(Badsess);
  216.         return -1;
  217.     }
  218.     /* Unwedge anyone waiting for a domain resolution, etc */
  219.     alert(sp->proc,EABORT);
  220.     shutdown(sp->s,2);
  221.     if(sp->type == FTP)
  222.         shutdown(sp->cb.ftp->data,2);
  223.     return 0;
  224. }
  225. int
  226. dokick(argc,argv,p)
  227. int argc;
  228. char *argv[];
  229. void *p;
  230. {
  231.     struct session *sp;
  232.  
  233.     sp = (struct session *)p;
  234.     if(argc > 1)
  235.         sp = sessptr(argv[1]);
  236.  
  237.     if(sp == NULLSESSION){
  238.         tprintf(Badsess);
  239.         return -1;
  240.     }
  241.     sockkick(sp->s);
  242.     if(sp->type == FTP)
  243.         sockkick(sp->cb.ftp->data);
  244.     return 0;
  245. }
  246.  
  247. struct session *
  248. newsession(name,type)
  249. char *name;
  250. int type;
  251. {
  252.     register struct session *sp;
  253.     int i;
  254.  
  255.     for(i=0,sp=Sessions;i < Nsessions;sp++,i++)
  256.         if(sp->type == FREE)
  257.             break;
  258.     if(i == Nsessions)
  259.         return NULLSESSION;
  260.  
  261.     sp->type = type;
  262.     sp->s = -1;
  263.     if(name != NULLCHAR)
  264.         sp->name = strdup(name);
  265.     sp->proc = Curproc;
  266.     /* Create standard input and output sockets. Output is
  267.      * translated to local end-of-line by default
  268.      */
  269.     Curproc->input =  sp->input = socket(AF_LOCAL,SOCK_STREAM,0);
  270.     seteol(Curproc->input,Eol);
  271.     sockmode(Curproc->input,SOCK_BINARY);
  272.     Curproc->output = sp->output = socket(AF_LOCAL,SOCK_STREAM,0);
  273.     seteol(Curproc->output,Eol);
  274.     sockmode(Curproc->output,SOCK_ASCII);
  275.  
  276.     /* on by default */
  277.     sp->ttystate.crnl = sp->ttystate.edit = sp->ttystate.echo = 1;
  278.     sp->flowmode = 0;    /* Off by default */
  279.     sp->row = MOREROWS;
  280.     sp->morewait = 0;
  281. #ifndef ATARI    
  282.     newscreen(sp);
  283.     swapscreen(Current,sp);
  284. #endif
  285.     Current = sp;
  286.     return sp;
  287. }
  288. void
  289. freesession(sp)
  290. struct session *sp;
  291. {
  292.     if(sp == NULLSESSION)
  293.         return;
  294.     pwait(NULL);    /* Wait for any pending output to go */
  295.     rflush();
  296.  
  297.     if(sp->proc1 != NULLPROC)
  298.         killproc(sp->proc1);
  299.     sp->proc1 = NULLPROC;
  300.     if(sp->proc2 != NULLPROC)
  301.         killproc(sp->proc2);
  302.     sp->proc2 = NULLPROC;
  303.  
  304.     free_p(sp->ttystate.line);
  305.     sp->ttystate.line = NULLBUF;
  306.     if(sp->s != -1)
  307.         close_s(sp->s);
  308.     if(sp->record != NULLFILE){
  309.         fclose(sp->record);
  310.         sp->record = NULLFILE;
  311.     }
  312.     free(sp->rfile);
  313.     sp->rfile = NULLCHAR;
  314.     if(sp->upload != NULLFILE){
  315.         fclose(sp->upload);
  316.         sp->upload = NULLFILE;
  317.     }
  318.     free(sp->ufile);
  319.     sp->ufile = NULLCHAR;
  320.     free(sp->name);
  321.     sp->name = NULLCHAR;
  322.     sp->type = FREE;
  323.  
  324.     close_s(sp->input);
  325.     sp->input = -1;
  326.     sp->proc->input = -1;
  327.     close_s(sp->output);
  328.     sp->output = -1;
  329.     sp->proc->output = -1;
  330.  
  331. #ifndef ATARI    
  332.     freescreen(sp);
  333. #endif
  334.     if(Current == sp){
  335.         Current = Command;
  336. #ifndef ATARI
  337.         swapscren(NULLSESSION,Command);
  338. #endif        
  339.         alert(Display,1);
  340.     }
  341.     if(Lastcurr == sp)
  342.         Lastcurr = NULLSESSION;
  343. }
  344. /* Control session recording */
  345. int
  346. dorecord(argc,argv,p)
  347. int argc;
  348. char *argv[];
  349. void *p;
  350. {
  351.     struct session *sp;
  352.     char *mode;
  353.  
  354.     sp = (struct session *)p;
  355.     if(sp == NULLSESSION){
  356.         tprintf("No current session\n");
  357.         return 1;
  358.     }
  359.     if(argc > 1){
  360.         if(sp->rfile != NULLCHAR){
  361.             fclose(sp->record);
  362.             free(sp->rfile);
  363.             sp->record = NULLFILE;
  364.             sp->rfile = NULLCHAR;
  365.         }
  366.         /* Open new record file, unless file name is "off", which means
  367.          * disable recording
  368.          */
  369.         if(strcmp(argv[1],"off") != 0){
  370.             if(sockmode(sp->output,-1) == SOCK_ASCII)
  371.                 mode = APPEND_TEXT;
  372.             else
  373.                 mode = APPEND_BINARY;
  374.  
  375.             if((sp->record = fopen(argv[1],mode)) == NULLFILE)
  376.                 tprintf("Can't open %s: %s\n",argv[1],sys_errlist[errno]);
  377.             else
  378.                 sp->rfile = strdup(argv[1]);
  379.         }
  380.     }
  381.     if(sp->rfile != NULLCHAR)
  382.         tprintf("Recording into %s\n",sp->rfile);
  383.     else
  384.         tprintf("Recording off\n");
  385.     return 0;
  386. }
  387. /* Control file transmission */
  388. int
  389. doupload(argc,argv,p)
  390. int argc;
  391. char *argv[];
  392. void *p;
  393. {
  394.     register struct session *sp;
  395.  
  396.     sp = (struct session *)p;
  397.     if(sp == NULLSESSION){
  398.         tprintf("No current session\n");
  399.         return 1;
  400.     }
  401.     if(argc < 2){
  402.         if(sp->ufile != NULLCHAR)
  403.             tprintf("Uploading %s\n",sp->ufile);
  404.         else
  405.             tprintf("Uploading off\n");
  406.         return 0;
  407.     }
  408.     if(strcmp(argv[1],"stop") == 0 && sp->upload != NULLFILE){
  409.         /* Abort upload */
  410.         fclose(sp->upload);
  411.         sp->upload = NULLFILE;
  412.         free(sp->ufile);
  413.         sp->ufile = NULLCHAR;
  414.         killproc(sp->proc2);
  415.         sp->proc2 = NULLPROC;
  416.         return 0;
  417.     }
  418.     /* Open upload file */
  419.     if((sp->upload = fopen(argv[1],READ_TEXT)) == NULLFILE){
  420.         tprintf("Can't read %s: %s\n",argv[1],sys_errlist[errno]);
  421.         return 1;
  422.     }
  423.     sp->ufile = strdup(argv[1]);
  424.     /* All set, invoke the upload process */
  425.     sp->proc2 = newproc("upload",1024,upload,0,sp,NULL,0);
  426.     return 0;
  427. }
  428. /* File uploading task */
  429.  
  430. void __stdargs upload(unused,sp1,p)
  431. int unused;
  432. void *sp1;
  433. void *p;
  434. {
  435.     struct session *sp;
  436.     int oldf;
  437.     char *buf;
  438.  
  439.     sp = (struct session *)sp1;
  440.  
  441.     /* Disable newline buffering for the duration */
  442.     oldf = setflush(sp->s,-1);
  443.  
  444.     buf = mallocw(BUFSIZ);
  445.     while(fgets(buf,BUFSIZ,sp->upload) != NULLCHAR)
  446.         if(usputs(sp->s,buf) == EOF)
  447.             break;
  448.  
  449.     free(buf);
  450.     usflush(sp->s);
  451.     setflush(sp->s,oldf);
  452.     fclose(sp->upload);
  453.     sp->upload = NULLFILE;
  454.     free(sp->ufile);
  455.     sp->ufile = NULLCHAR;
  456.     sp->proc2 = NULLPROC;
  457. }
  458.  
  459.